'use strict';

/**
 * 配置逻辑控制器
 */
const Code = require('../common/error_code');
const Cons = require('../common/constants');
const configModel = require('../models/config.model');
const systemUrl = require('../../config/global_config').ipc;
const globalConfig = require('../../config/global_config');
const httpUtil = require('../utils/http');
const hobotUtil = require('../utils/hobot_util');
const pushClient = require('../utils/redis_publish');

/**
 * 查询配置
 */
async function query(ctx) {
    const params = ctx.request.query;
    // 校验参数
    if (!params.type) {
        return ctx.error(Code.RET_CONFIG_QUERY_ERR_PARAM);
    }
    if (params.type < Cons.CONFIG_TYPE_START || params.type > Cons.CONFIG_TYPE_STOP) {
        return ctx.error(Code.RET_CONFIG_QUERY_ERR_PARAM);
    }

    const config = await configModel.findOne({ _id: params.type });
    let rst = '';
    // 【注意】如果修改部门的数据结构，一定要跟识别服务同步，因为大家都要用到部门这块数据
    if (params.type == Cons.CONFIG_TYPE_DEPT) {
        let tmp = [];
        if (config && config.c_va) {
            config.c_va.forEach(function (item, index) {
                tmp.push({ value: item.value + '', label: item.label });
            }
            );
        }
        if (tmp.length > 0) {
            rst = tmp;
        }
    } else if (params.type == Cons.CONFIG_TYPE_SETTING) {
        if (config && config.c_va) {
            rst = config.c_va;
        } else {
            // 给个默认值
            rst = globalConfig.config;
        }
    } else if (params.type == Cons.CONFIG_TYPE_ATTENDANCE) {
        if (!config || !config.c_va) {
            rst = {
                work_on: Cons.WORK_ON_TIME,
                work_on_limit: 0,
                work_off: Cons.WORK_OFF_TIME,
                work_off_limit: 0
            };
        } else {
            rst = config.c_va;
        }
    } else if (params.type == Cons.CONFIG_TYPE_LOGO) {
        if (!config || !config.c_va) {
            rst = {
            };
        } else {
            rst = config.c_va;
        }
    } else if (params.type == Cons.CONFIG_TYPE_USERS_SHOW) {
        if (!config || !config.c_va) {
            rst = {};
        } else {
            rst = config.c_va;
        }
    } else if (params.type == Cons.CONFIG_TYPE_LIVENESS) {
        if (!config || !config.c_va) {
            rst = {
                detect: false
            };
        } else {
            rst = config.c_va;
        }
    } else if (params.type == Cons.CONFIG_TYPE_STRANGER_SWITCH) {
        if (!config || !config.c_va) {
            rst = {
                switch: false
            };
        } else {
            rst = config.c_va;
        }
    } else {
        rst = config ? config.c_va : '';
    }

    if (rst instanceof String) {
        rst = JSON.parse(rst)
    }

    ctx.success(Code.RET_CONFIG_QUERY_OK, rst)
}

/**
 * 配置信息
 * Cons.CONFIG_TYPE_ATTENDANCE 考勤设置
 */
async function add(ctx) {
    const params = ctx.request.body;
    // 校验参数
    if (!params.type || !params.value) {
        return ctx.error(Code.RET_CONFIG_ADD_ERR_PARAM);
    }
    if (params.type < Cons.CONFIG_TYPE_START || params.type > Cons.CONFIG_TYPE_STOP) {
        return ctx.error(Code.RET_CONFIG_ADD_ERR_PARAM);
    }

    // 理论上是要校验格式的，BUT
    const value = params.value;
    // const value = JSON.parse(params.value);

    await configModel.update({ _id: params.type }, { c_va: value }, { upsert: true });

    // 系统配置写入文件，防止数据库还没初始化成功不能使用
    if (params.type == Cons.CONFIG_TYPE_SETTING) {
        globalConfig.setConfig(value)
    }

    if (params.type == Cons.CONFIG_TYPE_LOGO || params.type == Cons.CONFIG_TYPE_USERS_SHOW) {
        const message = {
            type: "",
            msg: value
        };
        if (params.type == Cons.CONFIG_TYPE_USERS_SHOW) {
            message.type = Cons.CUSTOM_USER_SHOW_SETTING;
        } else if (params.type == Cons.CONFIG_TYPE_LOGO) {
            message.type = Cons.CUSTOM_LOGO_SETTING;
        }
        if (message.type.length != 0) {
            pushClient.publish(Cons.REDIS_PUSH_CUSTOM_SETTING, message);
        }
    }

    ctx.success(Code.RET_CONFIG_ADD_OK);
}

async function dept_internal(params) {
    // 校验参数
    if (!params.action) {
        return -1;
    }
    if (params.action != Cons.CONFIG_DEPT_ACTION_ADD && params.action != Cons.CONFIG_DEPT_ACTION_DEL
        && params.action != Cons.CONFIG_DEPT_ACTION_MOD) {
        return -1;
    }
    if (params.action == Cons.CONFIG_DEPT_ACTION_ADD && !params.label) {
        return -1;
    }
    if (params.action == Cons.CONFIG_DEPT_ACTION_DEL && !params.value) {
        return -1;
    }
    if (params.action == Cons.CONFIG_DEPT_ACTION_MOD && !params.value && !params.label) {
        return -1;
    }

    // 先占坑，把部门配置生成
    let cdt = { _id: Cons.CONFIG_TYPE_DEPT };
    await configModel.update(cdt, {}, { upsert: true });

    let upd = {};
    let val = params.value;
    // 增
    if (params.action == Cons.CONFIG_DEPT_ACTION_ADD) {
        // 名字重复校验
        const dept = await configModel.findOne({ _id: Cons.CONFIG_TYPE_DEPT, 'c_va.label': params.label });
        if (dept) {
            return -2;
        }

        // 获取部门value值
        const depts = await configModel.findOne(cdt);
        val = 0;
        if (depts && depts.c_va && depts.c_va.length > 0) {
            val = depts.c_va[depts.c_va.length - 1].value + 1;
        }

        upd = {
            $push: {
                c_va: {
                    $each: [{ value: val, label: params.label }],
                    $sort: { value: 1 }
                }
            }
        };
    }
    // 删
    else if (params.action == Cons.CONFIG_DEPT_ACTION_DEL) {
        upd = {
            $pull: {
                c_va: { value: Number(params.value) }
            }
        };
    }
    // 改
    else if (params.action == Cons.CONFIG_DEPT_ACTION_MOD) {
        cdt = { _id: Cons.CONFIG_TYPE_DEPT, 'c_va.value': Number(params.value) };
        upd = { 'c_va.$.label': params.label }
    }
    await configModel.update(cdt, upd);
    return val;
}

/**
 * 部门增删改
 */
async function dept(ctx) {
    const params = ctx.request.body;
    let res = dept_internal(params);
    if (res == -1) {
        return ctx.error(Code.RET_CONFIG_DEPT_ERR_PARAM);
    } else if (res == -2) {
        return ctx.error(Code.RET_CONFIG_DEPT_ERR_EXIST);
    } else {
        return ctx.success(Code.RET_CONFIG_DEPT_OK, { dept_value: res + '' });
    }
}

/**
 * 获取网卡接口信息
 */
async function getEno(ctx) {
    const rst = await httpUtil.post(systemUrl.update, { target: 'system' });
    if (rst && rst.status_code === 0) {
        ctx.success(Code.RET_CONFIG_ENO_QUERY_OK, rst.interfaces);
    } else {
        ctx.error(Code.RET_CONFIG_ENO_QUERY_ERR_SERVER);
    }
}

/**
 * 修改特定以太网接口IP
 */
async function setIp(ctx) {
    const params = ctx.request.body;
    // 校验参数
    if (!params.interface || !params.ifconfig) {
        return ctx.error(Code.RET_CONFIG_ENO_SETTING_ERR_PARAM);
    }
    if (!params.ifconfig.ip || !params.ifconfig.mask || !params.ifconfig.gateway || !params.ifconfig.dns) {
        return ctx.error(Code.RET_CONFIG_ENO_SETTING_ERR_PARAM);
    }
    if (!hobotUtil.isIp(params.ifconfig.ip) || !hobotUtil.isIp(params.ifconfig.gateway)
        || !hobotUtil.isIp(params.ifconfig.dns)) {
        return ctx.error(Code.RET_CONFIG_ENO_SETTING_ERR_IP);
    }
    if (!hobotUtil.isNumber(Number(params.ifconfig.mask))) {
        return ctx.error(Code.RET_CONFIG_ENO_SETTING_ERR_MASK);
    }

    // IP配置文件/etc/sysconfig/network-scripts/ifcfg-<接口名>
    const rst = await httpUtil.post(systemUrl.update,
        {
            target: 'system',
            content: {
                interface: params.interface,
                ip_config: {
                    address: params.ifconfig.ip,
                    mask: Number(params.ifconfig.mask),
                    gateway: params.ifconfig.gateway,
                    dns: params.ifconfig.dns
                }
            }
        });
    if (rst && rst.status_code === 0) {
        // 重置配置文件
        globalConfig.initConfig(params.ifconfig.ip);

        await configModel.update({ _id: Cons.CONFIG_TYPE_SETTING }, { c_va: globalConfig.config }, { upsert: true });

        ctx.success(Code.RET_CONFIG_ENO_SETTING_OK);
    } else {
        ctx.error(Code.RET_CONFIG_ENO_SETTING_ERR_SERVER);
    }
}

/**
 * 重启服务器
 */
async function restart(ctx) {
    const rst = await httpUtil.post(systemUrl.restart, {
        target: 'system',
        content: {
            service: 'machine'
        }
    });
    if (rst && rst.status_code === 0) {
        ctx.success(Code.RET_CONFIG_RESTART_OK);
    } else {
        ctx.error(Code.RET_CONFIG_RESTART_ERR_SERVER);
    }
}

/**
 * 获取用户类型
 */
async function getUserType() {
    let config = await configModel.findOne({ _id: Cons.CONFIG_TYPE_USER_TYPE });
    return config ? config.c_va : '';
}

/**
 * 获取部门列表
 */
async function getDeptList() {
    const config = await configModel.findOne({ _id: Cons.CONFIG_TYPE_DEPT });
    return config ? config.c_va : '';
}

/**
 * 获取考勤配置
 */
async function getAttendanceConfig() {
    const config = await configModel.findOne({ _id: Cons.CONFIG_TYPE_ATTENDANCE });
    return config ? config.c_va : '';
}

async function getLogoConfig() {
    const config = await configModel.findOne({ _id: Cons.CONFIG_TYPE_LOGO });
    return config ? config.c_va : {};
}

async function getUsersShow() {
    const config = await configModel.findOne({ _id: Cons.CONFIG_TYPE_USERS_SHOW });
    return config ? config.c_va : {};
}

async function getLiveness() {
    const config = await configModel.findOne({ _id: Cons.CONFIG_TYPE_LIVENESS });
    return config ? config.c_va : { detect: false };
}

async function getStrangerSwitch() {
    const config = await configModel.findOne({ _id: Cons.CONFIG_TYPE_STRANGER_SWITCH });
    return config ? config.c_va : { switch: false };
}

/**
 * 获取配置的显示值
 */
function getConfigLabel(json, key) {
    if (!json) {
        return '';
    }
    const data = eval(json);
    for (let i = 0; i < data.length; i++) {
        const item = data[i];
        if (item.value == key) {
            return item.label;
        }
    }
    return '';
}

/**
 * 获取配置的key值
 */
function getConfigKey(json, label) {
    const data = eval(json);
    if (!data || data.length === 0) {
        return '';
    }
    for (let i = 0; i < data.length; i++) {
        const item = data[i];
        if (item.label == label) {
            return item.value;
        }
    }
    return '';
}

/**
 * 数据库连接成功回调
 */
async function dbCallback() {
    // 默认配置同步到数据库
    const config = await configModel.findOne({ _id: Cons.CONFIG_TYPE_SETTING });
    if (!config) {
        await configModel.create({ _id: Cons.CONFIG_TYPE_SETTING, c_va: globalConfig.config });
    }
    return console.log('mongoose open success')
}

async function init() {
    // 先占坑，把部门配置生成
    let cdt = { _id: Cons.CONFIG_TYPE_DEPT };
    await configModel.update(cdt, {}, { upsert: true });

}

async function clean(ctx) {
    //删除日志
    //删除临时文件
    ctx.success(Code.RET_CACHE_CLEAN_OK);
}

// 获取用户类型
exports.getUserType = getUserType;
// 获取部门列表
exports.getDeptList = getDeptList;
// 获取考勤配置
exports.getAttendanceConfig = getAttendanceConfig;
// 获取logo配置
exports.getLogoConfig = getLogoConfig;
// 获取用户显示配置
exports.getUsersShow = getUsersShow;
// 获取配置的显示值
exports.getConfigLabel = getConfigLabel;
// 获取配置的key值
exports.getConfigKey = getConfigKey;
// 数据库连接成功回调
exports.dbCallback = dbCallback;
// 获取活体检测开关
exports.getLiveness = getLiveness;
// 获取陌生人自动入库开关
exports.getStrangerSwitch = getStrangerSwitch;

exports.init = init;
exports.add = add;
// 查询配置
exports.query = query;
// 部门增删改
exports.dept = dept;
// 部门增删改 内部接口
exports.dept_internal = dept_internal;
// 获取网卡接口信息
exports.getEno = getEno;
// 修改特定以太网接口IP
exports.setIp = setIp;
// 重启服务器
exports.restart = restart;

//
exports.clean = clean;
